package com.feicheng.lanniao.aspect;

import com.feicheng.lanniao.entity.PayRecord;
import com.feicheng.lanniao.exception.SystemException;
import com.feicheng.lanniao.mapper.selectRecord.SelectRecordMapper;
import com.feicheng.lanniao.service.payRecord.PayRecordService;
import com.feicheng.lanniao.service.selectRecord.SelectRecordService;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.CodeSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Lazy(false)
public class StaticCountAspect {

    @Autowired
    private PayRecordService payRecordService;

    @Autowired
    private SelectRecordService selectRecordService;

    /**
     * 定义切入点,对要拦截的方法进行定义与限制,如包.类
     */
    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfCarBuyInfo)") //买车
    private void cutMethod() {}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfCarRentalInfo)")//求租车
    private void cutMethodCarRentalInfo(){}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfCarRentInfo)")//租车
    private void cutMethodCarRentInfo(){}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfCarSellInfo)")//卖车
    private void cutMethodCarSellInfo(){}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfHouseBuyInfo)")//买房
    private void cutMethodHouseBuyInfo(){}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfHouseLeaseInfo)")//求租房
    private void cutMethodHouseLeaseInfo(){}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfHouseRentInfo)")//租房
    private void cutMethodHouseRentInfo(){}

    @Pointcut("@annotation(com.feicheng.lanniao.anno.StaticSelectCountOfHouseSellInfo)")//卖车
    private void cutMethodHouseSellInfo(){}

    /**
     * 前置通知 : 在目标方法执行之前调用
     */
    @Around("cutMethod()")  //买房
    public void before(ProceedingJoinPoint joinPoint) {

        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }


        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("cbId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelect((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectRecord((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }

        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodCarRentalInfo()")  //求租车
    public void beforeCarRentalInfo(ProceedingJoinPoint joinPoint){

        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("CarId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectCarRentalRecord((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectCarRentalInfo((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodCarRentInfo()")   //租车
    public void beforeCarRentInfo(ProceedingJoinPoint joinPoint){
        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("crId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectCarRentRecord((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectCarRentRecord((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodCarSellInfo()")      //卖车
    public void beforeCarSellInfo(ProceedingJoinPoint joinPoint){
        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("carSellInfoId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectCarSellRecord((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectCarSellInfo((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodHouseBuyInfo()") //买房
    public void beforeHouseBuyInfo(ProceedingJoinPoint joinPoint){
        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("houseBuyId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectHouseBuyInfo((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectHouseBuyInfo((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodHouseLeaseInfo()") //求租房
    public void beforeHouseLeaseInfo(ProceedingJoinPoint joinPoint){
        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("leaseId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectHouseLeaseInfo((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectHouseLeaseInfo((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodHouseRentInfo()")  //租房
    public void beforeHouseRentInfo(ProceedingJoinPoint joinPoint){
        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("houseRentId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectHouseRentInfo((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectHouseRentInfo((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Around("cutMethodHouseSellInfo()") //卖房
    public void beforeHouseSellInfo(ProceedingJoinPoint joinPoint){
        //*********************************  次数统计 *******************************
        // TODO 查询一下这个client的**最新一条**paymentRecordId,假定现在是clientId = 1(从Session里面取)在访问,他已经支付过了,现在次数是0
        PayRecord payRecord = payRecordService.selectLatestPayRecordCountByClientId(1);

        //TODO 10条这个信息放在Redis中 ok   更新数据库中的 10 条 这个信息 顺便添加到数据库中
        //判断条数 是否大于10条 客户需求 : 交5元 可以浏览10条
        if (payRecord.getTimes() > 10) {
            throw new SystemException("浏览超过数量,请重新支付!");
        }
        //*******************************  查询去重 ,在此查询的时候不添加次数 *********************************
        //这个用户查询了这次信息,将这条记录放在查询记录表中,一共八个 以买车为例 selectId   cb_id(外键)    clientId
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint
                .getSignature()).getParameterNames();
        //获取参数名及其参数值
        for (int i = 0; i < paramNames.length; i++) {
            System.out.println(paramNames[i] + "," + args[i]);
            if (paramNames[i].equals("sellId")) {
                //获取CbId参数,判断一下一下是否已经查询过这条信息了,如果有这条信息则不进行插入
                if (selectRecordService.selectCountOfSelectHouseSellInfo((Integer) args[i], 1) == 0) {
                    selectRecordService.insertSelectHouseSellInfo((Integer)args[i],1);
                    //TODO 如果存在查询记录则不进行次数的增加
                    //根据主键更新这个用户的这次支付的times++
                    payRecordService.updateTimesOfLatestPayRecordById(payRecord.getPayRecordId());
                }
            }
        }
        //执行目标方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}


